/**
 * ServeurRequetes.java    19/04/2012
 */

package l3.info.Projet.Serveur;

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.server.UnicastRemoteObject;
import l3.info.Projet.Client.Utilisateur;
import l3.info.Projet.RMI.RequetesReseau;

/**
 * Passerelle RMI vers le serveur
 * @author Aboulkacem Hamid & Loïc Martinez
 */
public class ServeurRequetes extends UnicastRemoteObject implements
RequetesReseau {

    /** Nom du serveur RMI */
    private String name;

    /** Permet de savoir si le registre a été créé ou non */
    private boolean registryCree = false;

    /**
     * Constructeur
     * @param name, le nom du serveur RMI
     * @throws RemoteException, si un problème survient via RMI
     */
    public ServeurRequetes(String name) throws RemoteException {
        this.name = name;
    }

    /**
     * Constructeur
     * @param name, le nom du serveur RMI
     * @param port, le port du createRegistry
     * @throws RemoteException, si un problème survient via RMI
     */
    public ServeurRequetes(String name, int port) throws RemoteException {
        this.name = name;

        // On réserve le port
        LocateRegistry.createRegistry(port);

        lancer();
        System.out.println("Le serveur est lancé correctement");
        registryCree = true;
    }

    /**
     * Permet de lancer le serveur
     */
    public void lancer() {
        try {
            Naming.rebind(name, this);
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    /**
     * Permet d'arrêter le serveur
     */
    public void arreter() {
        try {
            Naming.unbind(name);
            UnicastRemoteObject.unexportObject(this, true);
            // System.gc();
        } catch (RemoteException e) {
            //e.printStackTrace();
        } catch (MalformedURLException e) {
            //e.printStackTrace();
        } catch (NotBoundException e) {
            //e.printStackTrace();
        }
    }

    /**
     * Setter de registryCree
     * @param b, true ou false
     */
    public void setRegistryCree(boolean b) {
        registryCree = b;
    }

    /**
     * @return registryCree
     */
    public boolean getRegistryCree() {
        return registryCree;
    }

    /**
     * Permet de savoir si un utilisateur existe, et si oui,
     * on va charger toutes ses données, sinon on ne fait rien
     * @param u, l'utilisateur à connecter
     * @param urlBd
     * @param userBd
     * @param passwdBd
     * @param tableUser
     * @param tableMessage
     */
    public Utilisateur utilisateurExists(Utilisateur u, String tableUser,
            String tableSuivi) throws RemoteException {

        DAOUtilisateur daoU = new DAOUtilisateur();

        if (daoU.getExistingUserTable(u, tableUser)) {
            // On remplit l'utilisateur avec toutes ses données
            return daoU.getDataFromUserTableWhenConnected(u,
                    tableUser, tableSuivi);
        }
        return u;
    }

    /**
     * Permet de savoir si l'utilisateur passé en paramètres existe
     * dans la base de données (bon pseudo et bon mot de passe)
     * @param u, l'utilisateur que l'on vérifie
     * @return l'utilisateur avec ses informations si la vérification
     *         a été bonne, tel quel sinon
     */
    public Utilisateur utilisateurExists(Utilisateur u) throws RemoteException {
        return utilisateurExists(u, "Utilisateur", "Suivre");
    }

    /**
     * Permet d'ajouter un utilisateur à suivre
     * @param myId, mon numutilisateur
     * @param id, le numutilisateur de la personne à suivre
     * @param table, la table suivre
     * @return le pseudo de la personne à suivre
     */
    public String suivreUtilisateur(int myId, int id,
            String table) throws RemoteException {
        DAOUtilisateurSuivi daoUS = new DAOUtilisateurSuivi();

        return daoUS.insertSuivreUtilisateur(myId, id, table);
    }

    /**
     * Permet d'ajouter un utilisateur à suivre
     * @param myId, mon numutilisateur
     * @param id, le numutilisateur de la personne à suivre
     * @return le pseudo de la personne à suivre
     */
    public String suivreUtilisateur(int myId, int id) throws RemoteException {
        return suivreUtilisateur(myId, id, "Suivre");
    }

    /**
     * Permet de supprimer un utilisateur suivi
     * @param myId, mon numutilisateur
     * @param idToDelete, le numutilisateur de la personne à supprimer
     * @param table, la table suivre
     */
    public void removeUser(int myId, int idToDelete, String table)
            throws RemoteException {
        DAOUtilisateurSuivi daoUS = new DAOUtilisateurSuivi();

        daoUS.removeUtilisateurASuivre(table, "numecrivain = " + idToDelete
                + " AND numlecteur = " + myId);
    }

    /**
     * Permet de supprimer un utilisateur suivi
     * @param myId, mon numutilisateur
     * @param idToDelete, le numutilisateur de la personne à supprimer
     */
    public void removeUser(int myId, int idToDelete) throws RemoteException {
        removeUser(myId, idToDelete, "Suivre");
    }
}